package com.rytong.tools.ui;

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.HashMap;
import com.rytong.tools.httpconnect.WaitDialog.Task;
import com.rytong.tools.utils.LPToastUtil;
import com.rytong.tools.utils.Utils;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.graphics.Paint.Style;
import android.graphics.drawable.BitmapDrawable;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.WebView;
import android.widget.AbsoluteLayout;
import android.widget.FrameLayout;
import android.widget.Gallery;
import android.widget.HorizontalScrollView;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.AbsoluteLayout.LayoutParams;

/**
 * 融易通产品管理器类所有的界面结构管理器都统一用这个类,此类的主要元素是一个绝对布局对象
 * 
 * @author Jade
 * 
 */

public class LPLayout extends Component {
    // 据框架右边距，据此判断align的right属性布局
    private int distanceToRight_;
    // 居中控件的宽度总和
    private int distanceOfCenter_;
    // 居中控件的宽度集合
    private ArrayList<Component> alCenter_;
    // body框架纵向边距
    public static int VMB;
    // body框架水平边距
    public static int HMB;
    // body框架子元素纵向间距
    public static int VGB;
    // body框架子元素横向间距
    public static int HGB;
    // form框架纵向边距
    public static int VMF;
    // form框架水平边距
    public static int HMF;
    // form框架子元素纵向间距
    public static int VGF;
    // form框架子元素横向间距
    public static int HGF;
    // div框架纵向边距
    public static int VMD;
    // div框架水平边距
    public static int HMD;
    // div框架子元素纵向间距
    public static int VGD;
    // div框架子元素横向间距
    public static int HGD;
    // td框架纵向边距
    public static int VMT;
    // td框架水平边距
    public static int HMT;
    // td框架子元素纵向间距
    public static int VGT;
    // td框架子元素横向间距
    public static int HGT;
    // tr宽度管理数组,改变量为tr控件专有
    int[] tdWidth_;
    // tr之间的分隔线颜色,该属性为非html标准属性
    private int separatorColor_ = Integer.MIN_VALUE;
    // 表格的纵向分隔线颜色。
    private int verticalSeparatorColor_ = Integer.MIN_VALUE;
    // table圆角矩形的弧度。
    public static final int TABLE_BG_RADIOUS_ = Utils.getScaledValueX(10);
    // tr背景的圆角矩形和外层table及分隔线的距离。
	public static final float TR_BG_MARGIN_ = 1.5f;
    // tr的样式。
    public CssStyle oldTRCssStyle_ = null;
    // tr的特殊标记。
    public boolean oldSpecialTR_ = false;
    // 横向分隔线背景。
    public Rect hSeparatorBg_ = null;
    // 横向分隔线主体。
    public Rect hSeparatorMain_ = null;
    // 纵向分隔线背景。
    public Rect vSeparatorBg_ = null;
    // 纵向分隔线本体。
    public Rect vSeparatorMain_ = null;
    
    // 一个横向滚动视图类，用来在td中内容过宽的时候加入，使得td中的内容可以左右滑动。
    public class HSView extends HorizontalScrollView{

    	// 需要处理的tr。
    	public Component currentTR_ = null;
    	// 需要处理的按钮。
    	public Component currentButton_ = null;
    	// 需要交还焦点的组件。
    	public Object focusObj_ = null;
    	
		public HSView(Context context) {
			super(context);
			// 隐藏横向滚动视图的滚动条。
			this.setHorizontalScrollBarEnabled(false);
			this.setVerticalScrollBarEnabled(false);
//			this.setHorizontalFadingEdgeEnabled(false);
//			this.setVerticalFadingEdgeEnabled(false);
		}
    	
		@Override
		public boolean onTouchEvent(MotionEvent ev) {
			switch (ev.getAction()) {
			case MotionEvent.ACTION_MOVE:
				if(focusObj_ != null){
					if(focusObj_ instanceof Component){
						return ((Component) focusObj_).realView_.onTouchEvent(ev);
					} else if(focusObj_ instanceof Gallery){
						return ((Gallery) focusObj_).onTouchEvent(ev);
					} else if(focusObj_ instanceof HorizontalScrollView){
						return ((HorizontalScrollView) focusObj_).onTouchEvent(ev);
					} else if(focusObj_ instanceof LPSelect){
						// 移动的时候恢复select的背景图。
            			if(((LPSelect) focusObj_).oldBG_ == null || "".equals(((LPSelect) focusObj_).oldBG_)){
            				realView_.setBackgroundColor(0);
            			} else {
            				realView_.setBackgroundColor(Color.parseColor(Component.fixedPX(
            						((LPSelect) focusObj_).oldBG_)));
            			}
					}
				}
				int offset = (int) Math.abs(xDown_ - ev.getX());
				if (offset > offset_) {
					// 移动tr恢复颜色。
					if(currentTR_ != null){
                		currentTR_.setCssStyle(((LPLayout) currentTR_).oldTRCssStyle_);
                		((MyLPLayout)currentTR_.realView_).isSpecialTRBg_ = ((LPLayout) currentTR_).oldSpecialTR_;
                		currentTR_.realView_.invalidate();
                		currentTR_ = null;
                	}
					// 移动按钮的时候恢复按钮的颜色。
                	if(currentButton_ != null && currentButton_.realView_.isEnabled() == true
                			&& currentButton_.upBG_ != -1){
                		currentButton_.realView_.setBackgroundResource(currentButton_.upBG_);
                		currentButton_ = null;
                	}
            	}
				break;
			case MotionEvent.ACTION_UP:
				if(focusObj_ != null){
					if(focusObj_ instanceof Component){
						return ((Component) focusObj_).realView_.onTouchEvent(ev);
					} else if(focusObj_ instanceof Gallery){
						return ((Gallery) focusObj_).onTouchEvent(ev);
					} else if(focusObj_ instanceof HorizontalScrollView){
						return ((HorizontalScrollView) focusObj_).onTouchEvent(ev);
					} else if(focusObj_ instanceof LPSelect){
						// 抬起的时候恢复select的背景图。
            			if(((LPSelect) focusObj_).oldBG_ == null || "".equals(((LPSelect) focusObj_).oldBG_)){
            				realView_.setBackgroundColor(0);
            			} else {
            				realView_.setBackgroundColor(Color.parseColor(Component.fixedPX(
            						((LPSelect) focusObj_).oldBG_)));
            			}
					}
				}
				// 抬起tr恢复颜色。
            	if(currentTR_ != null){
            		currentTR_.setCssStyle(((LPLayout) currentTR_).oldTRCssStyle_);
        			((MyLPLayout)currentTR_.realView_).isSpecialTRBg_ = ((LPLayout) currentTR_).oldSpecialTR_;
        			currentTR_.realView_.invalidate();
        			currentTR_ = null;
            	}
            	// 抬起按钮的时候恢复按钮的颜色。
            	if(currentButton_ != null && currentButton_.realView_.isEnabled() == true
            			&& currentButton_.upBG_ != -1){
            		currentButton_.realView_.setBackgroundResource(currentButton_.upBG_);
            		currentButton_ = null;
            	}
				break;
			default:
				break;
			}
			return super.onTouchEvent(ev);
		}
		
		@Override
        public boolean onInterceptTouchEvent(MotionEvent ev) {
            ViewGroup vg = (ViewGroup) getParent();
            if (vg == null) {
                return super.onInterceptTouchEvent(ev);
            } else {
                if (ev.getAction() == MotionEvent.ACTION_DOWN) {
                    // 将父scrollview的滚动事件拦截
                    vg.requestDisallowInterceptTouchEvent(true);
                } else if (ev.getAction() == MotionEvent.ACTION_UP) {
                    // 把滚动事件恢复给父Scrollview
                    vg.requestDisallowInterceptTouchEvent(false);
                } else if (ev.getAction() == MotionEvent.ACTION_MOVE) {
                	int yOffset = (int) Math.abs(yDown_ - ev.getY());
    				if (yOffset > offset_ / 2) { // 纵向移动距离超过了阀值，将焦点交还给父控件。
    					vg.requestDisallowInterceptTouchEvent(false);
    				}
                }
            }
            return super.onInterceptTouchEvent(ev);
        }
		
		// 释放资源的方法。
		public void releaseResource(){
			// 横向滚动视图释放资源。
			// 一般HSView中只添加一个横向滚动视图。
			if(getChildCount() > 0 && getChildAt(0) instanceof AbsoluteLayout){
				AbsoluteLayout as = (AbsoluteLayout) getChildAt(0);
				for (int j = 0; j < as.getChildCount(); j++) {
					View child = as.getChildAt(j);
					Component childComponent = (Component) getComponent(child);
	                if(childComponent != null){
	                	childComponent.releaseResource(childComponent);
	                }
	                childComponent = null;
				}
			}
		}
    }
    
    public class MyLPLayout extends AbsoluteLayout implements CompositedComponent {

    	// 是否再绘制tr的背景样式。
    	public boolean isSpecialTRBg_ = false;
    	// 是否再绘制td的背景样式。
    	public boolean isSpecialTDBg_ = false;
    	
        public MyLPLayout(Context context) {
            super(context);
            // TODO Auto-generated constructor stub
            // 该句必须添加,否则有些管理器的ondraw方法不会执行,但是界面上会出现该管理器的绘制效果
            setWillNotDraw(false);
        }

        @Override
        public Component composited() {
            // TODO Auto-generated method stub
            return LPLayout.this;
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            // body层不响应用户的任何点击操作
            if (getTag().equals("body"))// || getTag().equals("llv"))
                return true;
            int action = event.getAction();
            switch (action) {
            case MotionEvent.ACTION_DOWN:
            	// 按下tr时候变色。
            	trDownColor(tr_, llvSV_);
                xDown_ = event.getX();
                yDown_ = event.getY();
                break;
            case MotionEvent.ACTION_MOVE:
            	// 移动tr恢复颜色。
            	int offset = (int) Math.abs(yDown_ - event.getY());
            	if (offset > offset_) {
            		trMoveColor(tr_, llvSV_);
            	}
                // y方向有移动时超出了控件本身可视范围才有可能相应控件的y方向移动效果
                // 服务端定义了该控件的高度,且该控件的实际内容高度大于该限定高则执行管理器的纵向滑动操作
                if (null != parent_ && offset > offset_) {
                    moveY(yDown_ - event.getY());
                }
                break;
            case MotionEvent.ACTION_UP:
            	// 抬起tr恢复颜色。
            	trUpColor(tr_, llvSV_);
                // 预防控件出现连击效果
                long currentTime = System.currentTimeMillis();
                long timedifference = currentTime - LASTCLICKTIME;
                if (timedifference < 0) {
                    LASTCLICKTIME = currentTime;
                } else if (timedifference < jetLag_) {
                    LASTCLICKTIME = currentTime;
                    return false;
                } else {
                    LASTCLICKTIME = currentTime;
                }

                xUp_ = (int) event.getX();
                yUp_ = (int) event.getY();
                // 如果x或者y方向移动小于VALUE_个像素才判断为点击弹起，如果大于VALUE_个像素则判断为移动，不执行弹起效果
                if (Math.abs(xUp_ - xDown_) > offset_ || Math.abs(yUp_ - yDown_) > offset_) {
                    return false;
                }
                onClick((String) composited().property_.get("onclick"));
            default:
                break;
            }
            return true;
        }

        protected void onDraw(Canvas canvas) {
        	super.onDraw(canvas);
        	
        	//分行中设置body的背景色为透明
        	if(LPToastUtil.getInstance().isBranchBank){
        		String tag = (String) getTag();
        		if(tag != null){
        			if(tag.equalsIgnoreCase("body")){
        				realView_.setBackgroundColor(android.R.color.transparent);
        				return;        				
        			}
        			
        			//分行中如果td标签中含有文字，直接在此处画出
        			if(tag.equalsIgnoreCase("td")){
        				String text = getPropertyByName("text");
        				if(null != text && !"".equalsIgnoreCase(text) && this.getChildCount() <=0){
        					Paint txtPaint = new Paint();
        					txtPaint.setAntiAlias(true);
        					txtPaint.setTextSize(Utils.getFontSize(16));
        					txtPaint.setColor(Color.BLACK);
        					float y = (getHeight() + txtPaint.getTextSize())/2.0f;
        					canvas.drawText(text, Utils.getScaledValueX(5), y, txtPaint);
        				}
        			}
        		}
        	}

            if (isDrawBorder_()) {
                drawBorder(canvas);
                drawfilter(canvas, TABLE_BG_RADIOUS_);
            } else {
                drawfilter(canvas, 0);
            }
            drawTRFeature(canvas);
        }

        private void drawfilter(Canvas canvas, int radius) {
        	// 对于tr，如果特殊指定了他的背景色，那么就进行tr的背景绘制。
        	if(getTag() != null && ((String) getTag()).equalsIgnoreCase("tr") 
        			&& isSpecialTRBg_ == true && cssStyle_ != null){
        		Paint mPaint = new Paint();
        		mPaint.setAntiAlias(true);
        		// 指定了background-color或者color。
        		int bgColor = -1;
        		if(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR) != null){
        			if(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR).contains("FFFFFF")){
        				cssStyle_.setProperty(CssStyle.BACKGROUNDCOLOR, "#FFFFFE");
        			}
        			bgColor = Color.parseColor(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR));
        		} else if(cssStyle_.getProperty(CssStyle.COLOR) != null){
        			if(cssStyle_.getProperty(CssStyle.COLOR).contains("FFFFFF")){
        				cssStyle_.setProperty(CssStyle.COLOR, "#FFFFFE");
        			}
        			bgColor = Color.parseColor(cssStyle_.getProperty(CssStyle.COLOR));
        		}
        		if(bgColor != -1){ // 如果拿到了背景色。
        			mPaint.setColor(bgColor);
        		} else { // 没拿到背景色的时候先设置透明。
        			mPaint.setColor(0);
        			// 指定了filter。
        			if (cssStyle_.getProperty(CssStyle.FILTER) != null){
        				LinearGradient mLinearGradient_;
        				if (cssStyle_.gradientType == 1) {// 水平渐变
        					mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        							cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        				} else {// 垂直渐变
        					mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        							cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        				}
        				mPaint.setShader(mLinearGradient_);
        				mPaint.setAlpha((int)(cssStyle_.alpha * 255));
        			}
        		}
        		drawTRBg(mPaint, canvas);
        	}
        	// 如果是td，且指定了td的背景色属性，那么就进行td的背景色绘制。
        	else if(getTag() != null && ((String) getTag()).equalsIgnoreCase("td") 
        			&& isSpecialTDBg_ == true && cssStyle_ != null){
        		Paint mPaint = new Paint();
        		mPaint.setAntiAlias(true);
        		// 指定了background-color或者color。
        		int bgColor = -1;
        		if(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR) != null){
        			if(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR).contains("FFFFFF")){
        				cssStyle_.setProperty(CssStyle.BACKGROUNDCOLOR, "#FFFFFE");
        			}
        			bgColor = Color.parseColor(cssStyle_.getProperty(CssStyle.BACKGROUNDCOLOR));
        		} else if(cssStyle_.getProperty(CssStyle.COLOR) != null){
        			if(cssStyle_.getProperty(CssStyle.COLOR).contains("FFFFFF")){
        				cssStyle_.setProperty(CssStyle.COLOR, "#FFFFFE");
        			}
        			bgColor = Color.parseColor(cssStyle_.getProperty(CssStyle.COLOR));
        		}
        		if(bgColor != -1){ // 如果拿到了背景色。
        			mPaint.setColor(bgColor);
        		} else {
        			mPaint.setColor(0);
        			// 指定了filter。
        			if (cssStyle_.getProperty(CssStyle.FILTER) != null){
        				LinearGradient mLinearGradient_;
        				if (cssStyle_.gradientType == 1) {// 水平渐变
        					mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        							cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        				} else {// 垂直渐变
        					mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        							cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        				}
        				mPaint.setShader(mLinearGradient_);
        				mPaint.setAlpha((int)(cssStyle_.alpha * 255));
        			}
        		}
        		drawTDBg(mPaint, canvas);
        	}
        	// 对于其它控件，还是按照原来的画法进行绘制。
        	else {
        		if (cssStyle_ != null) {
        			// 渐变属性
        			LinearGradient mLinearGradient_;
        			Paint mPaint = new Paint();
        			mPaint.setAntiAlias(true);
        			if (cssStyle_.gradientType == 1) {// 水平渐变
        				mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        						cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        			} else {// 垂直渐变
        				mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] { cssStyle_.startColorStr,
        						cssStyle_.endColorStr }, null, Shader.TileMode.MIRROR);
        			}
        			mPaint.setShader(mLinearGradient_);
        			mPaint.setAlpha((int)(cssStyle_.alpha * 255));
        			RectF f = new RectF(0, 0, getWidth(), getHeight());
        			// 如果是table，而且样式中指明边线宽度为0，那么就绘制直角背景。
        			if(getTag() != null && getTag().equals("table") && getPropertyByName("border") != null
        					&& getPropertyByName("border").equals("0")){
        				canvas.drawRoundRect(f, 0, 0, mPaint);
        			} else {
        				canvas.drawRoundRect(f, radius, radius, mPaint);
        			}
        		}
        		
        		//分行中特殊处理，给form 和 div 画背景
        		/*if(LPToastUtil.getInstance().isBranchBank && !Component.hasCssStyle){
        			if(null != getTag() && (getTag().equals("form") || getTag().equals("div"))){
            			// 渐变属性
            			LinearGradient mLinearGradient_;
            			Paint mPaint = new Paint();
            			mPaint.setAntiAlias(true);
            			mLinearGradient_ = new LinearGradient(0, 0, width_, height_, new int[] {0xffFFFFFE,0xffFFFFFE}, null, Shader.TileMode.MIRROR);
            			mPaint.setShader(mLinearGradient_);
            			mPaint.setAlpha((int)(0.8 * 255));
            			RectF f = new RectF(0, 0, getWidth(), getHeight());
            			canvas.drawRoundRect(f, radius, radius, mPaint);
        			}
        		}*/
        	}
        }
        
        @Override
        public void addView(View child) {
        	super.addView(child);
        }
        
        @Override
        public void addView(View child, int index) {
        	super.addView(child, index);
        }

    }

    public Component getChildAt(int i) {
        View view = ((ViewGroup) realView_).getChildAt(i);
        return getComponent(view);
    }
    
	/**
     * 绘制tr控件的背景。
     * 
     * @param paint 画笔。
     * @param canvas 画布。
     */
    public void drawTRBg(Paint paint, Canvas canvas){
    	if(getParent() == null){
    		return;
    	}
    	parent_ = (LPLayout) getParent();
    	// 需要绘制的圆角矩形大小，这里设置和四周的间隔为TR_BG_MARGIN_。上边距由于边线有双色效果，因此空隙要加大一些。
    	RectF f = null;
    	if(getWidth() > (TR_BG_MARGIN_ * 2) && getHeight() > (Math.max(2, Utils.getScaledValueY(1.5f))) + TR_BG_MARGIN_){
    		f = new RectF(TR_BG_MARGIN_, Math.max(TR_BG_MARGIN_, Math.max(2, Utils.getScaledValueY(1.5f))), 
    				getWidth() - TR_BG_MARGIN_, getHeight() - TR_BG_MARGIN_);
    	} else {
    		f = new RectF(0, 0, getWidth(), getHeight());
    	}
    	// 圆角矩形的弧度。
    	float fRadious = Math.max(TABLE_BG_RADIOUS_ - TR_BG_MARGIN_, 0);
    	// 如果发现所在的table的属性指明了border为0，那么就进行直角背景绘制。
    	if(parent_.getPropertyByName("border") != null && parent_.getPropertyByName("border").equals("0")){
    		fRadious = 0f;
    	}
    	// 4个角的弧度数组。
    	float[] radii = null;
    	// 绘图的路径。
    	Path path = new Path();
    	// 如果这个table只有一行tr，那么就绘制四个角都是圆角的矩形。
		if(parent_.getChildCount() == 1){
			radii = new float[]{ fRadious, fRadious, fRadious, fRadious, fRadious, fRadious, fRadious, fRadious };
		}
		// 如果这个tr处于第一行，那么就绘制上部圆角的矩形。
        else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == 0){
        	radii = new float[]{ fRadious, fRadious, fRadious, fRadious, 0f, 0f, 0f, 0f };
		}
		// 如果这个tr处于最后一行，那么就绘制下部圆角的矩形。
        else if(parent_.getChildCount() > 1 && 
        		parent_.indexOfChild(realView_) == parent_.getChildCount() - 1){
        	radii = new float[]{ 0f, 0f, 0f, 0f, fRadious, fRadious, fRadious, fRadious };
        }
        // 对于多行tr的table，首尾之间的tr画成方角矩形。
        else if(parent_.getChildCount() > 2){ // 至少三行。
        	radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f };
        }
		// 绘制tr的背景。
		if(radii != null){
			path.addRoundRect(f, radii, Path.Direction.CW);
			canvas.drawPath(path, paint);
		}
    }
    
    /**
     * 绘制td的背景色。
     * 
     * @param paint 画笔。
     * @param canvas 画布。
     */
    public void drawTDBg(Paint paint, Canvas canvas){
    	if(getParent() == null || (getParent() != null && getParent().getParent() == null)){
    		return;
    	}
    	parent_ = (LPLayout) getParent();
    	// 需要绘制的圆角矩形大小，这里设置和四周的间隔为TR_BG_MARGIN_。由于tr分隔线是双色，因此上边距应加大一些。
    	RectF f = null;
    	if(getWidth() > (TR_BG_MARGIN_ * 2) && getHeight() > (Math.max(2, Utils.getScaledValueY(1.5f))) + TR_BG_MARGIN_){
    		f = new RectF(TR_BG_MARGIN_, Math.max(TR_BG_MARGIN_, Math.max(2, Utils.getScaledValueY(1.5f))), 
    				getWidth() - TR_BG_MARGIN_, getHeight() - TR_BG_MARGIN_);
    	} else {
    		f = new RectF(0, 0, getWidth(), getHeight());
    	}
    	// 圆角矩形的弧度。
    	float fRadious = Math.max(TABLE_BG_RADIOUS_ - TR_BG_MARGIN_, 0);
    	// 如果所在的table中的样式指明了border为0，那么绘制直角背景。
    	if(parent_.getParent().getPropertyByName("border") != null
    			&& parent_.getParent().getPropertyByName("border").equals("0")){
    		fRadious = 0f;
    	}
    	// 4个角的弧度数组。
    	float[] radii = null;
    	// 绘图的路径。
    	Path path = new Path();
    	// 注意现在的parent_指的是td所在的tr。
    	/**
    	 * table只有一行tr的情况。
    	 */
		if(parent_.getParent().getChildCount() == 1){
			// tr里面只有一个td。
			if(parent_.getChildCount() == 1){
				radii = new float[]{ fRadious, fRadious, fRadious, fRadious, fRadious, fRadious, fRadious, fRadious };
			}
			// tr里面有多个td，td处于第一个的位置。
			else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == 0){
				radii = new float[]{ fRadious, fRadious, 0f, 0f, 0f, 0f, fRadious, fRadious };
			}
			// tr里面有多个td，td处于最后一个的位置。
			else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == parent_.getChildCount() - 1){
				radii = new float[]{ 0f, 0f, fRadious, fRadious, fRadious, fRadious, 0f, 0f };
			}
			// tr里面有多个td，td处于中间的位置。
			else if(parent_.getChildCount() > 2){
				radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f };
			}
		}
		/**
		 * 如果这个tr处于第一行的情况。
		 */
        else if(parent_.getParent().getChildCount() > 1 && ((LPLayout) parent_.getParent()).indexOfChild(parent_.realView_) == 0){
        	// tr里面只有一个td。
        	if(parent_.getChildCount() == 1){
        		radii = new float[]{ fRadious, fRadious, fRadious, fRadious, 0f, 0f, 0f, 0f };
        	}
        	// tr里面有多个td，td处于第一个的位置。
        	else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == 0){
        		radii = new float[]{ fRadious, fRadious, 0f, 0f, 0f, 0f, 0f, 0f };
        	}
        	// tr里面有多个td，td处于最后一个的位置。
        	else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == parent_.getChildCount() - 1){
        		radii = new float[]{ 0f, 0f, fRadious, fRadious, 0f, 0f, 0f, 0f };
        	}
        	// tr里面有多个td，td处于中间的位置。
        	else if(parent_.getChildCount() > 2){
        		radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f };
        	}
		}
		/**
		 * 如果这个tr处于最后一行的情况。
		 */
        else if(parent_.getParent().getChildCount() > 1 && 
        		((LPLayout) parent_.getParent()).indexOfChild(parent_.realView_) == parent_.getParent().getChildCount() - 1){
        	// tr里面只有一个td。
        	if(parent_.getChildCount() == 1){
        		radii = new float[]{ 0f, 0f, 0f, 0f, fRadious, fRadious, fRadious, fRadious };
        	}
        	// tr里面有多个td，td处于第一个的位置。
        	else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == 0){
        		radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, fRadious, fRadious };
        	}
        	// tr里面有多个td，td处于最后一个的位置。
        	else if(parent_.getChildCount() > 1 && parent_.indexOfChild(realView_) == parent_.getChildCount() - 1){
        		radii = new float[]{ 0f, 0f, 0f, 0f, fRadious, fRadious, 0f, 0f };
        	}
        	// tr里面有多个td，td处于中间的位置。
        	else if(parent_.getChildCount() > 2){
        		radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f };
        	}
        }
        /**
         * 对于多行tr的table，tr处于table中间的情况。
         */
        else if(parent_.getParent().getChildCount() > 2){ // 至少三行。
        	radii = new float[]{ 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f };
        }
		// 绘制tr的背景。
		if(radii != null){
			path.addRoundRect(f, radii, Path.Direction.CW);
			canvas.drawPath(path, paint);
		}
    }

    /**
     * 绘制tr控件的特征，有分割线或者右箭头
     * 
     * @param canvas
     */
    public void drawTRFeature(Canvas canvas) {
        if (null != getTag() && getTag().equalsIgnoreCase("tr")) {
        	parent_ = (LPLayout) getParent();
        	Paint paint = new Paint();
        	paint.setAntiAlias(true);
            /**
             * 画水平分隔线：
             */
            if (parent_ != null && parent_.getChildCount() > 1 && parent_.separatorColor_ != Integer.MIN_VALUE) {
                int index = parent_.indexOfChild(realView_); // 获得tr序号。
                if (index == 0) { // 首tr。
                } else { // 其他的tr。
                	paint.setStyle(Style.FILL);
                	// 画分隔线背景。
                	paint.setColor(Color.WHITE);
                	if(hSeparatorBg_ == null){
                		hSeparatorBg_ = new Rect(0, 0, realView_.getWidth(), 
                				Math.max(2, Utils.getScaledValueY(1.5f)));
                	}
                	canvas.drawRect(hSeparatorBg_, paint);
                	// 画分隔线。
                 	paint.setColor(parent_.separatorColor_);
                    if(hSeparatorMain_ == null){
                    	hSeparatorMain_ = new Rect(0, 0, realView_.getWidth(), 
                    			Math.max(1, Utils.getScaledValueY(0.75f)));
                    }
                    canvas.drawRect(hSeparatorMain_, paint);
                }
            }
            /**
             * 画垂直的分隔线。
             */
        	// 如果tr里面有td，而且指定了分割线颜色。
        	if(parent_ != null && childrenList_ != null && childrenList_.size() > 0 
        			&& parent_.verticalSeparatorColor_ != Integer.MIN_VALUE){
        		int start = 0; // 画竖线的开始位置。
        		for (int i = 0; i < childrenList_.size() - 1; i++) {
        			start += childrenList_.get(i).width_;
    				paint.setStyle(Style.FILL);
                	// 画分隔线背景。
                	paint.setColor(Color.WHITE);
                	if(vSeparatorBg_ == null){
                		vSeparatorBg_ = new Rect(start - Math.max(1, Utils.getScaledValueX(0.75f)), 0,
                				start + Math.max(1, Utils.getScaledValueX(0.75f)), getHeight());
                	}
                	canvas.drawRect(vSeparatorBg_, paint);
                	// 画分隔线。
                 	paint.setColor(parent_.verticalSeparatorColor_);
                    if(vSeparatorMain_ == null){
                    	vSeparatorMain_ = new Rect(start, 0, 
                    			start + Math.max(1, Utils.getScaledValueX(0.75f)), getHeight());
                    }
                    canvas.drawRect(vSeparatorMain_, paint);
    			}
        	}
        }
    }

    /**
     * 取得字节点控件，该节点控件并非都是可显示的子控件， LPHidden控件没有实体控件，可通过该方法取得。
     * 
     * @param i
     * @return
     */
    public Component getCompChildAt(int i) {
        if (null != childrenList_ && !childrenList_.isEmpty()) {
            return childrenList_.get(i);
        }
        return null;
    }

    @Override
    public void initRealView(Activity activity, String value) {
        // TODO Auto-generated method stub
        realView_ = new MyLPLayout(activity);
    }

    public void addView(Component c) {
        if (null != realView_ && null != c && null != c.realView_)
            ((MyLPLayout) realView_).addView(c.realView_);
    }
    
    /**
     * 实现控件的y方向移动
     * 
     * @param event
     * @param offset
     *            移动偏移值
     */
    public void moveY(float offset) {
        // TODO Auto-generated method stub
        // body层不参与滑动操作
        // if (getTag().equalsIgnoreCase("body"))
        // return;
        // // y方向上的最大偏移
        // int yMaxOffset = hSelfMax_ - height_;
        // if (height_ > 0 && hSelfMax_ > height_) {
        // // 服务端定义了该控件的高度,且该控件的实际内容高度大于该限定值则执行管理器的纵向滑动操作
        // moveYOK(offset);
        // } else if ((height_ < 0) || (hSelfMax_ <= height_)) {
        // // 如果管理器没有移动操作，则将移动操作向上传递
        // if (null != parent_)
        // parent_.moveY(offset);
        // }
        //
        // // 在移动的过程中，检测控件是否需要进行翻页操作
        // String nexturl = ((String) getPropertyByName("nextUrl")).trim();
        // if (!nexturl.equals("") && (realView_.getScrollY() == yMaxOffset) && !throwPageIsWork_) {
        // throwPageIsWork_ = true;
        // nexturl = Utils.insteadOfSpecillCharacter(nexturl, false);
        // throwPage(this, nexturl);
        // }
    }

    private void moveYOK(float offset) {

        // TODO Auto-generated method stub
        // y方向上的最大偏移
        int yMaxOffset = hSelfMax_ - height_;

        // y方向的位移
        if (Math.abs(offset) < yMaxOffset) {
            // 如果移动距离小于该控件的可移动范围，则直接移动该距离
            scrollTo(getScrollX(), getScrollY() + (int) offset);
        } else {
            if (null != parent_) {
                parent_.moveY(offset);
            }
        }
        // 校正控件的垂直移动
        if (getScrollY() < 0) {
            scrollTo(getScrollX(), 0);
        }
        if (getScrollY() > yMaxOffset) {
            scrollTo(getScrollX(), yMaxOffset);
        }
    }

    void addView(Component c, int index) {
        // TODO Auto-generated method stub
        if (c instanceof LPLayout) {
            ((MyLPLayout) realView_).addView(c.getLPView(), index);
        } else {
            ((MyLPLayout) realView_).addView(c.realView_, index);
        }
    }

    /**
     * 
     * 添加用于翻页功能的显示域，当table控件存在nextUrl属性时，需要在表格控件最后再添加一个子元素用于显示正在加载的提示信息
     */

    private void addLoadingView() {

        // 控件的唯一标志

        String loading = "loading";

        // TODO Auto-generated method stub

        if (getTag().equalsIgnoreCase("table") && !getPropertyByName("nextUrl").equals("")

        && !getChildAt(getChildCount() - 1).getTag().equalsIgnoreCase(loading)) {

            try {

                LPLabel label = new LPLabel();
                String text = "显示更多结果...";
                label.initRealView(getActivity(), text);
                label.stringArr_ = new String[1];
                label.stringArr_[0] = text;
                // 设置显示文字居中
                label.textAlign_ = "center";
                label.cssStyle_ = new CssStyle();
                label.setStyleByName(CssStyle.WIDTH, width_ + "");
                label.setTag(loading);

                label.setTextColor(Color.BLACK);

                // 获得table的最后一个tr

                Component c = getChildAt(getChildCount() - 1);

                int h = c.ySelfMax_ - c.ySelfTop_;

                // 根据table的最后一个行高设置该控件的高度

                label.setLayoutParams(new LayoutParams(width_, h, 0, 0));

                addView(label);

                label.adjustXY();

            } catch (Exception e) {

                // TODO Auto-generated catch block

                Utils.printException(e);

            }

        } else if (getTag().equalsIgnoreCase("table") && null == getPropertyByName("nextUrl")

        && !getChildAt(getChildCount() - 1).getTag().equalsIgnoreCase(loading)) {

            // 如果没有nextUrl标记，则检查table控件内是否有loading显示域控件，如果有，将其清除

            removeView(getChildAt(getChildCount() - 1));

        }

    }

    /**
     * 该方法主要用于指定控件的大小\显示颜色\样式。如果服务端没有给定输出样式大小则要自行计算一个合适的大小应用于该控件。
     * Mould this component with its shape, color, size and so on.
     * 
     * @return
     * @throws Exception
     *             TODO
     */
    public void mouldH() throws Exception {
        super.mouldH();
        if (getTag().equalsIgnoreCase("body")) {
            // llv框架层不参与任何样式指定，是在外部计算它的可显示大小
            setLLVLayout();
        }
        addLoadingView();
        setSeparator();
        setVerticalSeparator();
        if (null != cssStyle_) {
            final String bgImageUrl = (String) cssStyle_.getProperty(CssStyle.BGIMAGEURL);

            if (null != bgImageUrl && !"".equals(bgImageUrl)) {
            	if(getTag() != null && "body".equalsIgnoreCase(getTag())){
            		if(getContext() != null && getContext() instanceof BaseView){
            			final BaseView bv = (BaseView) getContext();
            			// 如果图片缓存为null，那么就新建一个图片缓存。
            			if(bv.bmCache_ == null){
            				bv.bmCache_ = new HashMap<String, SoftReference<Bitmap>>();
            			}
            			final String w = (String) cssStyle_.getProperty(CssStyle.WIDTH);
                        final String h = (String) cssStyle_.getProperty(CssStyle.HEIGHT);
                        // 如果缓存中没有需要的背景图，那么就先建立一个。
                        if(bv.bmCache_.get(w + h + bgImageUrl) == null
                        		|| bv.bmCache_.get(w + h + bgImageUrl).get() == null
                        		|| bv.bmCache_.get(w + h + bgImageUrl).get().isRecycled()){
                        	final Bitmap imgBg = 
                        			scaledBitmapByCSS(Utils.getBitmapFromResources(getContext(), bgImageUrl));
                        	bv.bmCache_.put(w + h + bgImageUrl, new SoftReference<Bitmap>(imgBg));
                        }
                        Activity activity = (Activity) getContext();
                		long index = Thread.currentThread().getId();
                		if (index == 1) {
                			if (null != cssStyle().content_
                					&& cssStyle().content_.indexOf(CssStyle.BGIMAGEURL) > cssStyle().content_
                					.indexOf(CssStyle.BACKGROUNDCOLOR))
                				realView_.setBackgroundDrawable(new BitmapDrawable(
                						bv.bmCache_.get(w + h + bgImageUrl).get()));
                		} else {
                			activity.runOnUiThread(new Runnable() {
                				
                				@Override
                				public void run() {
                					if (null != cssStyle().content_
                							&& cssStyle().content_.indexOf(CssStyle.BGIMAGEURL) > cssStyle().content_
                							.indexOf(CssStyle.BACKGROUNDCOLOR))
                						realView_.setBackgroundDrawable(new BitmapDrawable(
                								bv.bmCache_.get(w + h + bgImageUrl).get()));
                				}
                			});
                		}
            		}
            	} else {
            		// 设置管理器的背景图片
            		final Bitmap imgBg = scaledBitmapByCSS(Utils.getBitmapFromResources(getContext(), bgImageUrl));
            		unFocusImg_ = imgBg;
            		Activity activity = (Activity) getContext();
            		long index = Thread.currentThread().getId();
            		if (index == 1) {
            			if (null != cssStyle().content_
            					&& cssStyle().content_.indexOf(CssStyle.BGIMAGEURL) > cssStyle().content_
            					.indexOf(CssStyle.BACKGROUNDCOLOR))
            				realView_.setBackgroundDrawable(new BitmapDrawable(unFocusImg_));
            		} else {
            			activity.runOnUiThread(new Runnable() {
            				
            				@Override
            				public void run() {
            					// TODO Auto-generated method stub
            					if (null != cssStyle().content_
            							&& cssStyle().content_.indexOf(CssStyle.BGIMAGEURL) > cssStyle().content_
            							.indexOf(CssStyle.BACKGROUNDCOLOR))
            						realView_.setBackgroundDrawable(new BitmapDrawable(unFocusImg_));
            				}
            				
            			});
            		}
            	}
            }
        }
        // 登记tr老的样式和特殊标记。
        if(getTag() != null && "tr".equals(getTag())){
        	oldTRCssStyle_ = cssStyle();
        	oldSpecialTR_ = ((MyLPLayout) realView_).isSpecialTRBg_;
        }
        
        //分行特殊处理，使得四边都有一定的距离 add by cheng.li 
        if(LPToastUtil.getInstance().isBranchBank && !Component.hasCssStyle){
        	if(null != getTag() && "body".equalsIgnoreCase(getTag())){
        		realView_.setPadding(Utils.getScaledValueX(10), Utils.getScaledValueX(5), Utils.getScaledValueX(10), Utils.getScaledValueX(5));
        	}
        }
    }

    private void setLongClickable(boolean b) {
        // TODO Auto-generated method stub
        if (null != realView_)
            realView_.setLongClickable(b);
    }

    /**
     * 检查tr控件的布局限制，并加以应用到td的子元素中去
     */
    void checkChildLayoutInTR() {
        // TODO Auto-generated method stub
        if (null != getTag() && getTag().toString().trim().equalsIgnoreCase("tr")) {
            // 遍历tr控件，查看是否存在布局限制
            // tr控件的横向布局参数默认居左
            String trhalign = "left";
            // tr控件的纵向布局参数默认居中
            String trvalign = "middle";
            // td控件的横向布局参数
            String tdhalign = "";
            // td控件的纵向布局参数
            String tdvalign = "";
            LPLayout td;
//            if (null != cssStyle()) {
//                // 获取后台限制的布局数据
//                trhalign = (String) cssStyle().getProperty("align");
//                if (null == trhalign)
//                    trhalign = "left";
//                trvalign = (String) cssStyle().getProperty("valign");
//                if (null == trvalign)
//                    trvalign = "middle";
//            }
            trhalign = getPropertyByName("align");
            if (null == trhalign)
                trhalign = "left";
            trvalign = getPropertyByName("valign");
            if (null == trvalign)
                trvalign = "middle";
            int size = getChildCount(); // 如果是tr，那么取得tr里面的td元素个数。
            int tdW;
            int tdH;
            LayoutParams lp; // 自己的布局参数。
            LayoutParams tdChildlp; // td子元素的布局参数。
            int tdSize; // td里面子元素的个数。
            Component tdChild; // td里面的子元素。
            // td元素的左右上下边距和宽高。
            int tdChildL;
            int tdChildT;
            int tdChildR = 0;
            int tdChildB = 0;
            int tdChildW;
            int tdChildH;
            // td元素的上一个td元素的左右上下边距和宽高。
            int preTdChildL = 0;
            int preTdChildT = 0;
            int preTdChildR = 0;
            int preTdChildB = 0;
            int preTdChildW = 0;
            int preTdChildH = 0;
            // td内子元素框架的整体属性
            int tdChildFrameleft; // td子元素们所处的框架的左边距。
            int tdChildFrameTop; // td子元素们所处的框架的上边距。
            int tdChildFrameRight; // td子元素们所处的框架的右边距。
            int tdChildFrameBottom; // td子元素们所处的框架的下边距。
            int tdChildFrameH; // td子元素们所处的框架的宽。
            int tdChildFrameW; // td子元素们所处的框架的高。
            CssStyle tdChildCS; // td子元素的样式。
            // td中子元素是否存在br,如果存在则垂直居中应该是相对于整个td子元素块做操作
            // 如果没有,说明所有的td子元素在一行,此时居中计算会有差异
            boolean hasBr; // 是否含有br换行。
            for (int i = 0; i < size; i++) {
                td = (LPLayout) getChildAt(i);
                tdhalign = "left";
                tdvalign = "middle";
//                if (null != td.cssStyle()) {
//                    // 获取后台限制的td布局数据
//                    tdhalign = (String) td.cssStyle().getProperty("align");
//                    if (null == tdhalign)
//                        tdhalign = trhalign;
//                    tdvalign = (String) td.cssStyle().getProperty("valign");
//                    if (null == tdvalign)
//                        tdvalign = trvalign;
//                }
                
                tdhalign = td.getPropertyByName("align");
                if (null == tdhalign)
                    tdhalign = trhalign;
                tdvalign = td.getPropertyByName("valign");
                if (tdvalign.equals("")){
                    if(!trvalign.equals("")){
                        tdvalign = trvalign;
                    } else {
                        tdvalign = "middle";
                    }
                }
                    
                
                // 取得每个td的宽高
                lp = (LayoutParams) td.getLayoutParams();
                if (lp.width > 0)
                    tdW = lp.width; // 如果指定了td的宽度，那么就设置td的宽度为指定的宽度。
                else
                    tdW = wSelfMax_; // 否则td的宽度是默认平分tr的宽度。

                if (lp.height > 0)
                    tdH = lp.height;
                else if(hSelfMax_ > 0)
                    tdH = hSelfMax_;
                else 
                    tdH = height_;//取td默认的高度：tr的高度

                tdChildFrameleft = 0;
                tdChildFrameTop = 0;
                tdChildFrameRight = 0;
                tdChildFrameBottom = 0;

                //删除横向滚动视图
                removeHorizontalScrollViewInTD(td);                
                tdSize = td.getChildCount();
                hasBr = false;
                // 循环遍历td中的元素得出子元素集合的大致框架参数
                for (int k = 0; k < tdSize; k++) {
                    // 取出td子元素的宽高
                    tdChild = td.getChildAt(k);
                    // 查看td子元素是否有br，如果有只标记一次
                    if (!hasBr)
                        hasBr = tdChild.isAfterBr_;
                    tdChildlp = (LayoutParams) tdChild.getLayoutParams();
                    if (tdChildlp.width > 0)
                        tdChildW = tdChildlp.width;
                    else
                        tdChildW = tdChild.wSelfMax_;
                    if (tdChildlp.height > 0)
                        tdChildH = tdChildlp.height;
                    else
                        tdChildH = tdChild.hSelfMax_;
                    tdChildL = tdChildlp.x;
                    tdChildT = tdChildlp.y;
                    tdChildR = tdW - tdChildL - tdChildW;
                    tdChildB = tdH - tdChildT - tdChildH;
                    if (k == 0) { // td里面第一个子元素。
                        tdChildFrameleft = tdChildL;
                        tdChildFrameTop = tdChildT;
                        tdChildFrameRight = tdChildR;
                        tdChildFrameBottom = tdChildB;
                    }
                    tdChildCS = tdChild.cssStyle();

                    if (null != tdChildCS) {
                        if (null != tdChildCS.getProperty(CssStyle.RIGHT)
                                && !tdChildCS.getProperty(CssStyle.RIGHT).equals("")) {
                            tdChildR = Integer.parseInt(fixedPX((String) tdChildCS.getProperty(CssStyle.RIGHT)));
                            tdChildR = Utils.getScaledValueY(tdChildR);
                        }
                        if (null != tdChildCS.getProperty(CssStyle.BOTTOM)
                                && !tdChildCS.getProperty(CssStyle.BOTTOM).equals("")) {
                            tdChildB = Integer.parseInt(fixedPX((String) tdChildCS.getProperty(CssStyle.BOTTOM)));
                            tdChildB = Utils.getScaledValueY(tdChildB);
                        }
                    }

                    /**
                     * 不停更新td子元素们所处框架的四个方向边距，且这个框架成扩大趋势。
                     */
                    tdChildFrameleft = Math.min(tdChildFrameleft, tdChildL);
                    tdChildFrameTop = Math.min(tdChildFrameTop, tdChildT);
                    tdChildFrameRight = Math.min(tdChildFrameRight, tdChildR);
                    tdChildFrameBottom = Math.min(tdChildFrameBottom, tdChildB);

                }

                tdChildFrameH = tdH - tdChildFrameBottom - tdChildFrameTop;
                tdChildFrameW = tdW - tdChildFrameleft - tdChildFrameRight;
                for (int k = 0; k < tdSize; k++) {
                    // 取出td子元素的宽高
                    tdChild = td.getChildAt(k);
                    tdChildlp = (LayoutParams) tdChild.getLayoutParams();
                    if (tdChildlp.width > 0)
                        tdChildW = tdChildlp.width;
                    else
                        tdChildW = tdChild.wSelfMax_;
                    if (tdChildlp.height > 0)
                        tdChildH = tdChildlp.height;
                    else
                        tdChildH = tdChild.hSelfMax_;

                    tdChildL = tdChildlp.x;
                    tdChildT = tdChildlp.y;
                    // 右边距和下边距直接取后台给的值。
                    String childRight = tdChild.getPropertyByName(CssStyle.RIGHT);
                    String childbottom = tdChild.getPropertyByName(CssStyle.BOTTOM);
                    try {
                    	if(childRight != null && !"".equalsIgnoreCase(childRight)){
                    		tdChildR = Utils.getScaledValueX(Float.parseFloat(Component.fixedPX(childRight)));
                    	} else {
                    		tdChildR = 0;
                    	}
					} catch (Exception e) {
					}
                    try{
                    	if(childbottom != null && !"".equalsIgnoreCase(childbottom)){
                    		tdChildB = Utils.getScaledValueX(Float.parseFloat(Component.fixedPX(childbottom)));
                    	} else {
                    		tdChildB = 0;
                    	}
                    } catch (Exception e){
                    }
//                    tdChildR = tdW - tdChildL - tdChildW;
//                    tdChildB = tdH - tdChildT - tdChildH;
                    tdChildCS = tdChild.cssStyle();
                    
                    
                    if (null == tdChildCS) {
                        // td子元素没有样式，则根据td或者tr的布局参数进行布局
                        if (tdChildFrameW >= tdW) {
                            // 如果td内子元素的宽度大于或者等于td自身的宽度，那td内的横向布局就没有什么意义，
                            // 就无所谓是居左还是居右或者居中对齐
                        	/**
                             * 如果内容的宽度大于td的宽度，那么给容器控件加入一个横向滚动视图。
                             */
                            if(tdChildFrameW > tdW && tdChild.getParent() instanceof LPLayout){
                            	insertHorizontalScrollViewInTD((LPLayout) tdChild.getParent(), tdChildFrameW);
                            }
                        } else if (tdhalign.equalsIgnoreCase("center")) {
                        	// 其他td，需要上一个td子元素的左边距，加上上一个td子元素的宽和右边距。
                        	// 如果控件在br节点之后，那么这个控件的左边距仍然是(tdW - tdChildFrameW) >> 1;
                        	if(k == 0 || tdChild.isAfterBr_){
                        		tdChildlp.x = (tdW - tdChildFrameW) >> 1;
                        	} else {
                        		tdChildlp.x = preTdChildL + preTdChildW + preTdChildR;
                        	}
                        	preTdChildL = tdChildlp.x;
                        	preTdChildW = tdChildW;
                        	preTdChildR = tdChildR;
                        } else if (tdhalign.equalsIgnoreCase("right")) {
                            tdChildlp.x = tdChildlp.x + (tdW - tdChildFrameW);
                        } 
                        if (tdChildFrameH >= tdH) {
                            // 如果td内子元素的高度大于或者等于td自身的高度，那td内的纵向布局就没有什么意义，
                            // 就无所谓是顶部还是底部或者居中对齐
                        } else if (tdvalign.equalsIgnoreCase("top")) {
                            // adjustXY计算的就是顶对齐方式，所以此处不需改变y
                        } else if (tdvalign.equalsIgnoreCase("bottom")) {
                            // tdChildlp.y = tdChildlp.y + (tdH - tdChildFrameH);
                            tdChildlp.y = tdChildlp.y + (tdH - tdChildFrameH - td.getVM() * 2);
                        } else {
                            // tdChildlp.y = tdChildlp.y + ((tdH - tdChildFrameH) >> 1);
                            tdChildlp.y = tdChildlp.y + ((tdH - tdChildFrameH - td.getVM() * 2) >> 1);
                        }

                        tdChild.setLayoutParams(tdChildlp);

                    } else {
                        if ((null == tdChildCS.getProperty(CssStyle.RIGHT) && null == tdChildCS
                                .getProperty(CssStyle.LEFT))
                                || (null == tdChildCS.getProperty(CssStyle.RIGHT) && tdChildCS.getProperty(
                                        CssStyle.LEFT).equals(""))
                                || (null == tdChildCS.getProperty(CssStyle.LEFT) && tdChildCS.getProperty(
                                        CssStyle.RIGHT).equals(""))
                                || (tdChildCS.getProperty(CssStyle.LEFT) != null
                                        && tdChildCS.getProperty(CssStyle.LEFT).equals("") && tdChildCS.getProperty(
                                        CssStyle.RIGHT).equals(""))) {
                            // 有样式，但没有确定左右对齐值
                            if (tdChildFrameW >= tdW) {
                                // 如果td内子元素的宽度大于或者等于td自身的宽度，那td内的纵向布局就没有什么意义，
                                // 就无所谓是居左还是居右或者居中对齐
                            	/**
                                 * 如果内容的宽度大于td的宽度，那么给容器控件加入一个横向滚动视图。
                                 */
                                if(tdChildFrameW > tdW && tdChild.getParent() instanceof LPLayout){
                                	insertHorizontalScrollViewInTD((LPLayout) tdChild.getParent(), tdChildFrameW);
                                }
                            } else if (tdhalign.equalsIgnoreCase("center")) {
                            	// 其他td中的子元素，需要上一个td子元素的左边距，加上上一个td子元素的宽和右边距。
                            	// 如果这个控件在br节点之后，那么这个控件的左边距仍然是(tdW - tdChildFrameW) >> 1;
                            	if(k == 0 || tdChild.isAfterBr_){
                            		tdChildlp.x = (tdW - tdChildFrameW) >> 1;
                            	} else {
                            		tdChildlp.x = preTdChildL + preTdChildW + preTdChildR;
                            	}
                            	preTdChildL = tdChildlp.x;
                            	preTdChildW = tdChildW;
                            	preTdChildR = tdChildR;
                            } else if (tdhalign.equalsIgnoreCase("right")) {
                                tdChildlp.x = tdChildlp.x + (tdW - tdChildFrameW);
                            }

                            tdChild.setLayoutParams(tdChildlp);
                        }
                        if ((null == tdChildCS.getProperty(CssStyle.TOP) && null == tdChildCS
                                .getProperty(CssStyle.BOTTOM))
                                || (null == tdChildCS.getProperty(CssStyle.TOP) && tdChildCS.getProperty(
                                        CssStyle.BOTTOM).equals(""))
                                || (null == tdChildCS.getProperty(CssStyle.BOTTOM) && tdChildCS.getProperty(
                                        CssStyle.TOP).equals(""))
                                || (tdChildCS.getProperty(CssStyle.BOTTOM) != null
                                        && tdChildCS.getProperty(CssStyle.BOTTOM).equals("") && tdChildCS.getProperty(
                                        CssStyle.TOP).equals(""))) {
                            // 有样式但没有上下对齐值
                            if (tdChildFrameH >= tdH) {
                                // 如果td内子元素的高度大于或者等于td自身的高度，那td内的纵向布局就没有什么意义，
                                // 就无所谓是顶部还是底部或者居中对齐
                            } else if (tdvalign.equalsIgnoreCase("top")) {
                                // adjustXY计算的就是顶对齐方式，所以此处不需改变y
                            } else if (tdvalign.equalsIgnoreCase("bottom")) {
                                if (hasBr)
                                    // tdChildlp.y = tdChildlp.y + (tdH - tdChildFrameH);
                                    tdChildlp.y = tdChildlp.y + (tdH - tdChildFrameH - td.getVM() * 2);
                                else
                                    tdChildlp.y = tdH - tdChildH;

                            } else{
                            	if (hasBr){
                            		//tdChildlp.y = tdChildlp.y + ((tdH - tdChildFrameH) >> 1);
                            		//tdChildlp.y = tdChildlp.y + ((tdH - tdChildFrameH - td.getVM() * 2) >> 1);
                            		if(k == 0){
                            			tdChildlp.y = td.getVM()+((tdH - tdChildFrameH - td.getVM() * 2) >> 1);
                            		}else if(tdChild.isAfterBr_){
		                        		//br高度，多个br时高度值比较大，做累加
										int brHeight = Math.max(td.getVM(), tdChild.getBrHeight());

		                        		preTdChildH = resetPreChildY(td,k,preTdChildH);
		                        		tdChildlp.y = preTdChildT + preTdChildH + preTdChildB + brHeight;
		                        	}
		                        	preTdChildT = tdChildlp.y;
		                        	preTdChildH = tdChildH;
		                        	preTdChildB = tdChildB;
                            	}else{
                            		tdChildlp.y = ((tdH - tdChildH) >> 1);       
                            	}
                            }
                            tdChild.setLayoutParams(tdChildlp);
                            if(hasBr && k == tdSize-1){
                            	resetPreChildY(td,tdSize,preTdChildH);
                            }
                        }
                        // 如果td中的控件给了左边距为0的样式（比如td里面加了个table），那么也要进行横向滚动视图的添加。
                        if(tdChildFrameW > tdW && tdChild.getParent() instanceof LPLayout
                        		&& tdChildCS != null && "0px".equalsIgnoreCase(tdChildCS.getProperty(CssStyle.LEFT))){
                        	insertHorizontalScrollViewInTD((LPLayout) tdChild.getParent(), tdChildFrameW);
                        }
                    }
                }
            }
        }
    }

    /**
     * 遇到换行符后，重新计算换行之后的控件的y坐标，使得竖向居中对齐
     * @param td
     * @param k
     * @param preChildH
     * @return
     */
    private int resetPreChildY(LPLayout td,int k,int h) {
		// TODO Auto-generated method stub
    	if(td == null || k == 0){
    		return h;
    	}
    	
    	int maxH = 0;
    	//当前到k位置的最后一个br的位置
    	int positionBR = 0;
    	for(int i = 0;i < k ;i++){
    		if((td.getChildAt(i).isAfterBr_)){
    			positionBR = i;
    		}
    	}
    	for(int i = positionBR;i < k;i++){
    		Component child = td.getChildAt(i);
    		if(null != child){
    			LayoutParams childLP = (LayoutParams) child.getLayoutParams();
    			int childH = childLP.height;
    			if(maxH < childH){
    				maxH = childH;
					for(int j = positionBR;j < i;j++){
						Component c = td.getChildAt(j);
						LayoutParams lp = (LayoutParams) c.getLayoutParams();
						if(!(c instanceof LPImageItem)){
							lp.height = maxH;							
						}
						c.setLayoutParams(lp);
					}
    			}else if(maxH > childH){
    				//arrow箭头图片
					if(!(child instanceof LPImageItem)){
						childLP.height = maxH;
					}else{
						childLP.y = childLP.y + childLP.height/2;
					}
					child.setLayoutParams(childLP);
    			}
    		}
    	}
		return maxH == 0 ? h:maxH;
	}

	/**
     * 查看子控件是否有right或者bottom属性修饰，如果有，则予以修正
     */
    void checkChildLayout() {
        // TODO Auto-generated method stub
        int size = getChildCount();
        Component child;
        CssStyle childCss;
        int r;
        int b;
        int w;
        int l;
        // 本控件框架的可视宽
        int parentW;
        // 本控件框架的可视高
        int parentH;
        int childW;
        int childH;
        LayoutParams childLayout;
        ViewGroup.LayoutParams vlp;
        // 控件对其模式默认左对齐
        String align = "left";
        if (null != getTag() && getTag().equalsIgnoreCase("body")) {
            // body框架层一般认为就是整个屏幕，且该层由于父系控件是framelayout，所以不会给该层指定绝对布局参数
            width_ = parentW = SCREENWIDTH;
            height_ = parentH = SCREENHEIGHT;
        } else {
            // 非body框架的布局参数都是绝对布局参数
            // 如果后台规定了控件的宽高值，则取相应的数据，若没有，则取计算后校正的数据
            ViewGroup vg = (ViewGroup) realView_.getParent();

            if (vg instanceof FrameLayout) {
                // 父控件布局为帧布局，但是还是必须安排自身控件子元素的布局
                android.widget.FrameLayout.LayoutParams flp = (android.widget.FrameLayout.LayoutParams) realView_
                        .getLayoutParams();
                parentW = flp.width;
                parentH = flp.height;
            } else {
                LayoutParams lp = (LayoutParams) getLayoutParams();
                if (lp.width > 0)
                    parentW = lp.width;
                else
                    parentW = wSelfMax_;

                if (lp.height > 0)
                    parentH = lp.height;
                else
                    parentH = hSelfMax_;
            }
        }

        // 初始化布局参数
        distanceToRight_ = 0;
        distanceOfCenter_ = 0;
        if (null == alCenter_)
            alCenter_ = new ArrayList(2);
        else
            alCenter_.clear();
        for (int i = 0; i < size; i++) {
            child = getChildAt(i);
            childCss = child.cssStyle();
            r = Integer.MIN_VALUE;
            b = Integer.MIN_VALUE;
            w = Integer.MIN_VALUE;
            l = Integer.MIN_VALUE;
            if (null != child.getPropertyByName("align") && !child.getPropertyByName("align").equals("")) {
                // 如果子元素没有样式，还需要检测是否有align属性，如果有，有可能需要做进一步布局操作
                align = (String) child.getPropertyByName("align");
            }
            // 分别获取子元素的right和bottom属性，如果有则需要进行布局处理
            if (null != childCss) {
                if (null != childCss.getProperty(CssStyle.RIGHT) && !childCss.getProperty(CssStyle.RIGHT).equals("")) {
                    r = Integer.parseInt(fixedPX((String) childCss.getProperty(CssStyle.RIGHT)));
                    r = Utils.getScaledValueX(r);
                }

                if (null != childCss.getProperty(CssStyle.LEFT) && !childCss.getProperty(CssStyle.LEFT).equals("")) {
                    l = Integer.parseInt(fixedPX((String) childCss.getProperty(CssStyle.LEFT)));
                    l = Utils.getScaledValueX(l);
                }

                if (null != childCss.getProperty(CssStyle.BOTTOM) && !childCss.getProperty(CssStyle.BOTTOM).equals("")) {
                    b = Integer.parseInt(fixedPX((String) childCss.getProperty(CssStyle.BOTTOM)));
                    b = Utils.getScaledValueY(b);
                }

                if (null != childCss.getProperty(CssStyle.WIDTH) && !childCss.getProperty(CssStyle.WIDTH).equals("")) {
                    w = Integer.parseInt(fixedPX((String) childCss.getProperty(CssStyle.WIDTH)));
                }

                if (null != childCss.getProperty(CssStyle.TEXTALIGN)
                        && !childCss.getProperty(CssStyle.TEXTALIGN).equals("")) {
                    align = (String) childCss.getProperty(CssStyle.TEXTALIGN);
                }
            }

            String tag = child.getTag();
            if (null != tag && tag.equalsIgnoreCase("llv"))
                continue;

            vlp = child.realView_.getLayoutParams();
            if (vlp instanceof FrameLayout.LayoutParams)
                continue;
            else
                childLayout = (LayoutParams) child.getLayoutParams();

            if (childLayout.width > 0)
                childW = childLayout.width;
            else
                childW = child.wSelfMax_;

            if (r != Integer.MIN_VALUE) {
                // 再定向位置为：父控件宽度-右边距-控件宽度-左边相对于其他控件的间距
                childLayout.x = parentW - r - childW - getHG();
                child.setLayoutParams(childLayout);
                distanceToRight_ = Math.max(distanceToRight_, r + childW + getHG());
            } else {
                // 控件样式没有指定右偏多少像素,则可以响应align属性或者text-align样式
                // 如果后台指定了left或者right，都会导致align属性或者text-align样式无效
                if (null != align && l == Integer.MIN_VALUE) {
                    if (align.equalsIgnoreCase("right")) {
                        if (w > 0) {
                            // 如果控件指定了宽度，那属性是相对于控件本身。
                            child.setGravity(Gravity.RIGHT);

                        } else {
                            // 如果没有指定控件宽度，则对其属性是相对于控件的父控件
                            // 再定向位置为：父控件宽度-右边距-控件宽度-左边相对于其他控件的间距-已经有的右边距长度
                            // 该右边距长度distanceToRight_变量主要为应对多个子元素right属性设置,作累加工作
                            childLayout.x = parentW - childW - distanceToRight_ - getHG();
                            child.setLayoutParams(childLayout);
                            distanceToRight_ += childW + getHG();
                        }

                    } else if (align.equalsIgnoreCase("center")) {
                        if (w > 0) {
                            // 如果控件指定了宽度，那属性是相对于控件本身。
                            child.setGravity(Gravity.CENTER);
                        } else {
                            // 如果没有指定控件宽度，则对其属性是相对于控件的父控件
                            // 先累加居中控件的总宽度
                            // 居中的宽度总和不计入第一个居中元素的间距
                            if (alCenter_.isEmpty())
                                distanceOfCenter_ = childW;
                            else
                                distanceOfCenter_ += getHG() + childW;
                            // 将居中控件添加到特定的集合，方便又多个居中控件可以快速遍历
                            alCenter_.add(child);
                        }
                    }
                }
            }

            if (b != Integer.MIN_VALUE) {
                // 此处不计算llv里面子元素的bottom效果，此时llv的高度还未确定
                if (null != getTag() && getTag().equalsIgnoreCase("llv"))
                    continue;
                if (childLayout.height > 0)
                    childH = childLayout.height;
                else
                    childH = child.hSelfMax_;

                childLayout.y = parentH - b - childH;

                child.setLayoutParams(childLayout);
            }

        }

        if (0 != distanceOfCenter_) {
            // 调整居中子元素的位置
            int centersize = alCenter_.size();
            int x = (parentW - distanceOfCenter_) >> 1;
            for (int i = 0; i < centersize; i++) {
                child = alCenter_.get(i);
                childLayout = (LayoutParams) child.getLayoutParams();
                childLayout.x = x;
                child.setLayoutParams(childLayout);

                if (childLayout.width > 0)
                    childW = childLayout.width;
                else
                    childW = child.wSelfMax_;
                x = x + getHG() + childW;
            }
        }
        alCenter_.clear();
        alCenter_ = null;

        if (null != getTag() && getTag().equalsIgnoreCase("body")) {
            // 在body节点中重新计算llv子控件的bottom对齐效果
            size = getChildCount();
            int llvIndex = 0;
            for (int i = 0; i < size; i++) {
                child = getChildAt(i);
                if (null != child.getTag() && child.getTag().equalsIgnoreCase("llv"))
                    llvIndex = i;
            }
            // 初始化llv下面状态栏的高度
            int statusH = 0;
            // 如果是llv中的子元素算bottom则还应减去界面下方状态栏的高度
            if (llvIndex == size - 2) {
                // 说明llv不是其父控件的最后一个控件
                Component nextC = getChildAt(llvIndex + 1);
                LayoutParams nextCLP = (LayoutParams) nextC.getLayoutParams();
                statusH = nextCLP.height;
            }
            // 取得llv控件,llv控件不可能为body框架的第一个控件
            child = getChildAt(llvIndex);
            if (null == child)
                return;
            Component llvChild;
            size = child.getChildCount();
            for (int i = 0; i < size; i++) {
                llvChild = child.getChildAt(i);
                childCss = llvChild.cssStyle();
                b = Integer.MIN_VALUE;
                // 分别获取子元素的right和bottom属性，如果有则需要进行布局处理
                if (null != childCss) {
                    if (null != childCss.getProperty(CssStyle.BOTTOM)
                            && !childCss.getProperty(CssStyle.BOTTOM).equals("")) {
                        b = Integer.parseInt(fixedPX((String) childCss.getProperty(CssStyle.BOTTOM)));
                        b = Utils.getScaledValueX(b);
                    }
                }
                if (llvChild.getLayoutParams() instanceof LayoutParams) {
                    childLayout = (LayoutParams) llvChild.getLayoutParams();
                } else {
                    return;
                }
                if (childLayout.height > 0)
                    childH = childLayout.height;
                else
                    childH = child.hSelfMax_;

                if (b != Integer.MIN_VALUE) {
                    childLayout.y = child.height_ - (b - statusH) - childH;
                    llvChild.setLayoutParams(childLayout);
                }
            }
        }
    }

    /**
     * 设置llv框架的宽高
     */
    private void setLLVLayout() {

        // TODO Auto-generated method stub
        if (null == realView_)
            return;
        int childSize = getChildCount();
        int w = AbsoluteLayout.LayoutParams.FILL_PARENT;

        // 由于body的父控件是一个帧布局,所以他的高度始终就是外层帧布局的高度,即SCREENHEIGHT
        int h = SCREENHEIGHT;
        CssStyle css;

        Component child = null;
        // 子元素高度
        int hChild = 0;
        // 含postion元素的总高度
        int hChildSum = 0;
        int indexLLV = Integer.MIN_VALUE;
        // 当w和h值一样时，做特殊处理，使其缩放后相等
        /**
         * 由于加入position:fixed属性的控件个数可能多于2个，因此要设法取得第一个和最后一个固定位置控件的高度。
         */
        int firstFixedHeight_ = -1;
        int lastFixedHeight_ = -1;
        for (int i = 0; i < childSize; i++) {
            child = getChildAt(i);
            css = null;
            css = child.cssStyle();
            // 取得llv框架在body框架的位置
            if (null != child.getTag() && child.getTag().equals("llv"))
                indexLLV = i;
            if (null != css && null != css.getProperty("position")) {
                if ((null != css.getProperty(CssStyle.HEIGHT)) && !css.getProperty(CssStyle.HEIGHT).equals("")) {
                    // 后台xml指定了与llv平级的控件高度
                    hChild = Integer.parseInt(fixedPX((String) css.getProperty(CssStyle.HEIGHT)));
                    if(firstFixedHeight_ == -1){ // 如果遇到了第一个fixed控件。
                    	firstFixedHeight_ = Utils.getScaledValueY(hChild);
                    } else { // 最后一个fixed控件的高度随时更新，用新的取代旧的。
                    	lastFixedHeight_ = Utils.getScaledValueY(hChild);
                    }
                } else {
                    // 后台xml未指定与llv平级的控件高度
                    hChild = child.hSelfMax_;
                    if(firstFixedHeight_ == -1){ // 如果遇到了第一个fixed控件。
                    	firstFixedHeight_ = hChild;
                    } else { // 最后一个fixed控件的高度随时更新，用新的取代旧的。
                    	lastFixedHeight_ = hChild;
                    }
                }
            }
        }
        hChildSum += (firstFixedHeight_ == -1 ? 0 : firstFixedHeight_) 
        		+ (lastFixedHeight_ == -1 ? 0 : lastFixedHeight_);
        if (indexLLV != Integer.MIN_VALUE) {
            // 计算llv的高度 ,llv的高度=父控件高度-含position属性的控件高度
            h = h - hChildSum;
            child = getChildAt(indexLLV);
            // 如果控件标记不为body，则对其限制大小
            LayoutParams lp = (LayoutParams) child.getLayoutParams();
            lp.width = child.width_ = w;
            lp.height = child.height_ = h;
            child.setLayoutParams(lp);
        }
    }

    /**
     * 修正tr和td控件的宽度，tr控件的宽度应该统一，而且是取最大宽 修正td的高度,td的高度应与tr的高度保持一致
     * 
     */
    void adjustTDWidth() {
        String tag = getTag();
        // 判断该控件是否为tr，如果是则参与相关操作
        if (tag.equalsIgnoreCase("tr")) {
            parent_ = (LPLayout) getParent(); // 拿到tr的父控件。指的是table。
            // 获取table的宽度，用于判定最后一个td的宽度
            int wParent = Integer.MIN_VALUE; // wParent表示table的宽度。
            if (null != parent_.cssStyle_ && null != parent_.cssStyle_.getProperty(CssStyle.WIDTH)
                    && !parent_.cssStyle_.getProperty(CssStyle.WIDTH).equals("")) {
                wParent = Integer.parseInt(fixedPX((String) parent_.cssStyle_.getProperty(CssStyle.WIDTH)));
                wParent = Utils.getScaledValueX(wParent);
            }

            int size = parent_.getChildCount(); // table中的tr的个数（表示table有多少行）。
            // 如果表格超过一行，且为最后一行才作td的对齐操作
            if (parent_.indexOfChild(realView_) == size - 1) {
                LPLayout tr = null;
                // for循环计算table中每一个tr的td宽度集合。
                for (int i = 0; i < size; i++) {
                    tr = (LPLayout) parent_.getChildAt(i);
                    if (null == tr)
                        continue;
                    tag = "";
                    tag = tr.getTag();
                    // 通过循环遍历得到tr的行宽集合
                    if (null != tag && !tag.equalsIgnoreCase("tr") || tr.getVisibility() == View.GONE)
                        continue;
                    tr.setTdWidth(tr);
                }

                LayoutParams lp;

                // 遍历所有tr的td，设置最大的td宽度
                int[] tdMaxWidth = null;
                for (int i = 0; i < size; i++) { // 遍历所有tr。
                    tr = (LPLayout) parent_.getChildAt(i);
                    if (tr.getVisibility() == View.GONE)
                        continue;
                    // 取得每个tr中td的个数
                    int tdSize = tr.tdWidth_.length;
                    if (null == tdMaxWidth)
                        tdMaxWidth = new int[tdSize]; // 每个tr里面td的最大宽度数组。
                    for (int j = 0; j < tdSize; j++) {
                    	// 两层for循环中，tdMaxWidth数组中最终存放的是每列td的最大宽度。
                        if (j < tdMaxWidth.length)
                            tdMaxWidth[j] = Math.max(tdMaxWidth[j], tr.tdWidth_[j]);
                    }
                }

                // 校正最后一列的宽度
                if (wParent != Integer.MIN_VALUE) {
                    // 如果xml指定了table的宽度，则最后一个td的宽度等于table宽度-前面所有宽度总和
                    int tempSize = tdMaxWidth.length;
                    int tdSum = 0;
                    for (int i = 0; i < tempSize; i++) {
                        if (i == tempSize - 1)
                            tdMaxWidth[i] = wParent - tdSum;
                        else
                            tdSum += tdMaxWidth[i];
                    }
                }

                LayoutParams trLayoutParams;
                // 重新设定每个td的宽度
                LPLayout td;
                for (int i = 0; i < size; i++) { // 遍历每一个tr。
                    tr = (LPLayout) parent_.getChildAt(i);
                    if (tr.getVisibility() == View.GONE)
                        continue;
                    trLayoutParams = (LayoutParams) tr.getLayoutParams();
                    // 取得每个tr中td的个数
                    int tdSize = tdMaxWidth.length;
                    tr.hSelfMax_ = 0;
                    tr.wSelfMax_ = 0;
                    tr.xSelfMax_ = 0;
                    tr.ySelfMax_ = 0;
                    tr.ySelfTop_ = 0;

                    for (int j = 0; j < tdSize; j++) {
                        td = (LPLayout) tr.getChildAt(j);
                        tag = td.getTag();
                        if (null != tag && !tag.equalsIgnoreCase("td") || !tag.equalsIgnoreCase("th")
                                || td.getVisibility() == View.GONE)
                            continue;
                        lp = (LayoutParams) td.getLayoutParams();
                        lp.width = tdMaxWidth[j];
                        if (lp.height < 0) {
                            // 逐步修正td的高度
                            // 优先取tr的高度，确认高度为后面的td元素居中布局做准备
                            lp.height = trLayoutParams.height;
                            if (lp.height < 0)
                                lp.height = td.hSelfMax_;
                        }
                        // 及时修改控件的wmax参数该值在后面的布局adjustxy中会用到.
                        td.wSelfMax_ = tdMaxWidth[j];
                        td.setLayoutParams(lp);
                        td.adjustXY();
                    }
                }
            }
        }
    }

    /**
     * 设置td的宽度
     * 
     * @param tr
     */
    private void setTdWidth(LPLayout tr) {
        // TODO Auto-generated method stub
        Component td;
        String tag;
        int size = tr.getChildCount();
        int maxWidth;
        tdWidth_ = new int[size];
        // for循环拿一个tr中每一个td对象。
        for (int i = 0; i < size; i++) {
            td = (LPLayout) tr.getChildAt(i);
            tag = td.getTag();
            // 通过循环遍历得到td宽度
            if (!tag.equalsIgnoreCase("td") || !tag.equalsIgnoreCase("th") || td.getVisibility() == View.GONE)
                continue;
            if (td.width_ > 0)
                // 如果xml限定了td的宽度则采用xml的设置
                maxWidth = td.width_;
            else{
            	// 由于结构是从里往外算，所以此时tr里面的元素都已计算完毕
            	maxWidth = td.wSelfMax_;
            }
            tdWidth_[i] = maxWidth;
        }
    }

    public int getChildCount() {
        // TODO Auto-generated method stub
        MyLPLayout temp = (MyLPLayout) realView_;
        return temp.getChildCount();
    }

    /**
     * 返回子元素个数，或者子节点控件个数，该个数并非等于该控件的实际显示控件大小
     * 
     * @return
     */
    public int getCompChildCount() {
        if (null != childrenList_ && !childrenList_.isEmpty())
            return childrenList_.size();
        else
            return 0;
    }

    public void setXMax(int max) {
        // TODO Auto-generated method stub
        xSelfMax_ = max;
    }

    public void setYMax(int max) {
        // TODO Auto-generated method stub
        ySelfMax_ = max;
    }

    public void setYTop(int max) {
        // TODO Auto-generated method stub
        ySelfTop_ = max;
    }

    protected StringBuffer getBuffFromForm(Component comp, StringBuffer buf, String action, Task task) {
        int size = getChildCount();
        Component temp;
        for (int i = 0; i < size; i++) {
            temp = getChildAt(i);
            if (temp.getVisibility() == View.VISIBLE) {
                if (temp instanceof Component) {
                    buf = temp.getBuffFromForm(temp, buf, action, task);
                } else {
                    LPLayout lpl = (LPLayout) comp;
                    buf = getBuffFromForm(lpl, buf, action, task);
                }
            } else {
                continue;
            }
        }
        return buf;
    }

    public void removeView(Component component) {
        // TODO Auto-generated method stub
        try {
            if (null == realView_ || null == component.realView_)
                return;
            AbsoluteLayout al = (AbsoluteLayout) realView_;
            al.removeView(component.realView_);
        } catch (Exception e) {
            Utils.printException(e);
        }
    }

    public void removeAllViews() {
        // TODO Auto-generated method stub
        try {
            int childCount = getChildCount();
            for (int i = 0; i < childCount; i++) {
                removeView(getChildAt(0));
            }
        } catch (Exception e) {
            Utils.printException(e);
        }
    }

    /**
     * 判断该控件是否是块级元素，其中div、tr、form、table当不给display样式的时候应另开一行。
     * 如果上述控件给定了display样式，但是值不为inline的话，依然需要另开一行。
     */
    private void isBlocklevelElement() {
        // TODO Auto-generated method stub
        String name = getTag();
        String display = null;
        if (cssStyle_ != null) {
            display = (String) cssStyle_.getProperty(CssStyle.DISPLAY);
        }
        if (null == display) {
            if (name.equalsIgnoreCase("div") || name.equalsIgnoreCase("tr") || name.equalsIgnoreCase("form")
                    || name.equalsIgnoreCase("table")) {
                isNewLine_ = true;
            }
        } else {
            if ((!display.equals("inline"))
                    && (name.equalsIgnoreCase("div") || name.equalsIgnoreCase("tr") || name.equalsIgnoreCase("form") 
                    		|| name.equalsIgnoreCase("table"))) {
                isNewLine_ = true;
            }
        }
    }

    public void releaseResource(Component component) {
        super.releaseResource(component);
        tdWidth_ = null;
    }
    
    /**
     * 根据获取的宽高值重新定义xy
     */
    @Override
    public void adjustXY() {
        // 在整个应用程序中只有绝对布局,但是如果直接将控件加到界面上或者Dialog�?它的布局会变成帧布局,这种情况不需要计算它的XYXY
        ViewGroup vg = (ViewGroup) realView_.getParent();

        if (vg instanceof FrameLayout) {
            // 父控件布局为帧布局，但是还是必须安排自身控件子元素的布局
        } else {
            if (null != getTag() && getTag().equalsIgnoreCase("body")) {
            	// 父控件是body的话不进行任何操作。
            } else {
                if (realView_.getVisibility() == View.GONE)
                    return;
                // TODO Auto-generated method stub
                // 先判定管理器是不是块状元素
                isBlocklevelElement();

                // 取得父控件的相关布局参数
                LPLayout lpl = (LPLayout)getComponent(vg);

                if (null == lpl) // 如果父控件为null，就不进行接下来的工作了。
                    return;
                int left = Integer.MIN_VALUE; // 从服务器端拿到的左边距。
                int top = Integer.MIN_VALUE; // 从服务器端拿到的上边距。
                if (null != cssStyle_) { // 若服务器给定了左边距和上边距，就进行赋值。
                    Object temp = cssStyle_.getProperty(CssStyle.LEFT);
                    if (null != temp && !temp.equals("")) {
                        left = Utils.getScaledValueX(Integer.parseInt(fixedPX(temp)));
                    }
                    temp = null;
                    temp = cssStyle_.getProperty(CssStyle.TOP);
                    if (null != temp && !temp.equals("")) {
                        top = Utils.getScaledValueY(Integer.parseInt(fixedPX(temp)));
                    }
                }
                int x = 0; // 左边距。
                int yTop = 0; // 上边距。
                /**
                 * 赋值左边距的操作。
                 */
                if ((null != cssStyle_) && (left != Integer.MIN_VALUE)) {
                    // 服务端已经规定了控件的左边距。
                    x = left;
                } else {
                    if (isAfterBr_) { // 如果这个控件在br之后，那么规定其左边距是0。
                        x = 0;
                    } else { // 否则这个控件的左边距是父控件的横向最大值（方便以后向右扩展）。
                        x = lpl.xSelfMax_;
                    }
                    if (isNewLine_) { // 本身需要新开一行的控件。
                        x = 0;
                    } else { 
                    	// 对于td和th之类的控件，不需要新开一行。
                        if(getTag().equalsIgnoreCase("th") || getTag().equalsIgnoreCase("td")){
                            int size = lpl.indexOfChild(realView_);
                            // 需要重新计算tr中所有td或者th的值。
                            x = 0;
                            for(int i = 0; i < size ; i++){
                            	Component com = lpl.getChildAt(i);
                            	AbsoluteLayout.LayoutParams comlp =
                            			(AbsoluteLayout.LayoutParams)com.getLayoutParams();
                            	
                            	if(i > 0){
                            	    Component preCom = lpl.getChildAt(i - 1);
                            	    AbsoluteLayout.LayoutParams prelp =
                            	    		(AbsoluteLayout.LayoutParams)preCom.getLayoutParams();
                            	    // 累加前一个td的左边距。
                            	    comlp.x = preCom.width_ + prelp.x;
                            	}
                            	
                            	x += com.width_;
                            }
                        } 
                        // 对于其他不需要新开一行的控件，左边距累加父控件的x方向最大宽度。
                        else{
                            x = lpl.xSelfMax_;
                        }
                    }
                    if (0 != x) {
                        // 表示该控件不是每排的第一个控件且报文未给他指定x值
                        // 此时我们应给控件累加一个默认的控件间距
                        x = x + lpl.getHG();
                    }
                }
                
                /**
                 * 赋值上边距的操作。
                 */
                //tr td th 不使用样式中定义的top值
                if ((null != cssStyle_) && (top != Integer.MIN_VALUE) 
                    && !(getTag().equalsIgnoreCase("td") || getTag().equalsIgnoreCase("th") || getTag().equalsIgnoreCase("tr"))) {
                    yTop = top; // 赋值上边距。
                    /**
                     * 纠正llv结构其直系子元素的高度。由于android与iphone在结构上的差异， 
                     * android产品为了更好的实现滚动效果，在界面上人为的插入了一层llv，
                     * 所以应对xml结构中的llv子元素的top作相应偏移处理
                     */
                    String tag = lpl.getTag(); // 拿父控件的标签。
                    if (tag.equalsIgnoreCase("llv")) {
                        // 表示该控件为llv层的直系子元素
                        if (lpl.llvTop_ == 0) {
                            // 计算llv里面直接子元素应该让度的top高度
                            lpl.llvTop_ = lpl.getLLVTop();
                        }

                        yTop = yTop - lpl.llvTop_;
                    }
                    if (isNewLine_) {
                        // 块级元素还应将自身的高度参与比较,计算yTop值，因为块级元素有效的话是前后都有类似br节点的效果。
                        if (height_ <= 0)
                            lpl.setYTop(Math.max(yTop + hSelfMax_, lpl.ySelfMax_));
                        else
                            lpl.setYTop(Math.max(yTop + height_, lpl.ySelfMax_));
                    }
                } else {
                    if (isAfterBr_) {
                        yTop = lpl.ySelfMax_ + brHeight_;
                        lpl.setYTop(yTop);
                    } else {
                        yTop = lpl.ySelfTop_;
                    }
                    if (isNewLine_) {
                        yTop = lpl.ySelfMax_;
                        // ytop不为零,表示控件不是其父控件的第一排控件
                        if (0 != lpl.ySelfTop_)
                            yTop = yTop + lpl.getVG();
                        else
                            // 如果不指定高度,且位于第一排,则应给与高度值
                            yTop = yTop + lpl.getVM();

                        // 块级元素还应将自身的高度参与比较,计算yTop值因为块级元素有效的话是前后都有类似br节点的效果
                        if (height_ <= 0)
                            lpl.setYTop(Math.max(yTop + hSelfMax_, lpl.ySelfMax_));
                        else
                            lpl.setYTop(Math.max(yTop + height_, lpl.ySelfMax_));
                    } else {
                        // ytop不为零,表示控件不是其父控件的第一排控件
                        if (0 != lpl.ySelfTop_)
                            yTop = yTop + lpl.getVG();
                        else
                            // 如果不指定高度,且位于第一排,则应给与高度值
                            yTop = yTop + lpl.getVM();
                    }
                }

                // 重新设置自身的布局参数
                left_ = x;
                top_ = yTop;
                LayoutParams lp = (LayoutParams) getLayoutParams();
                lp.x = left_;
                lp.y = top_;
                setLayoutParams(lp); // 到这里设置了左边距和上边距。

                yParentTop_ = yTop; // 控件自身相对于父控件的上边距。
                // 更新父控件的相关布局参数，为后面控件布局指定作准备
                if (isNewLine_) {
                    lpl.setXMax(x); // 需要开始新一行的控件，把左边距赋值为父控件的x方向最大值。
                    xParentMax_ = lpl.xSelfMax_; 
                } else { 
                	// 如果这个控件不需要换行，那么设置左边距为自身宽度最大值（每行第一个控件）；
                	// 或者累加前面控件的宽度和，以此作为父控件x方向最大值。
                    lpl.setXMax((x == 0) ? wSelfMax_ : (x + wSelfMax_));
                    xParentMax_ = lpl.xSelfMax_;
                }
                if (height_ <= 0) { // 没规定高度的时候，上边距是自身高度最大值。
                    lpl.setYMax(Math.max(yTop + hSelfMax_, lpl.ySelfMax_));
                    yParentMax_ = lpl.ySelfMax_;
                } else { // 规定了高度，上边距是height_值。
                    lpl.setYMax(Math.max(yTop + height_, lpl.ySelfMax_));
                    yParentMax_ = lpl.ySelfMax_;
                }
                // 设置父控件的最大宽度和最大高度。
                lpl.setHMax(Math.max(lpl.hSelfMax_, lpl.ySelfMax_ + lpl.getVM()));
                hParentMax_ = lpl.hSelfMax_;
                lpl.setWMax(Math.max(lpl.wSelfMax_, lpl.xSelfMax_));
                wParentMax_ = lpl.wSelfMax_;
            }
        }

        adjustTDWidth();
        checkChildLayoutInTR();
        checkChildLayout();
        // 对于table，如果其内容的高度大于table后台给定的高度，就给table加入一个纵向滚动视图。
        if(getTag() != null && "table".equalsIgnoreCase(getTag())
        		&& cssStyle_ != null && !"".equalsIgnoreCase((String) cssStyle_.getProperty(CssStyle.HEIGHT))){
        	float ewpHeight = -1;
        	try{
        		// 从后台拿出给定的高度值并按照屏幕纵向比例缩放。
        		ewpHeight = Utils.getScaledValueY(
        				Float.parseFloat(Component.fixedPX((String) cssStyle_.getProperty(CssStyle.HEIGHT))));
        	} catch (Exception e){}
        	if(ewpHeight > 0 && ewpHeight < hSelfMax_){ // 如果实际内容高度大于后台给定的高度，那么就加入一个纵向滚动视图。
        		insertVerticalScrollViewOutTable(this, hSelfMax_);
        	}
        }
        insertScrollView();
    }
    
    /**
     * 删除横向滚动视图
     * TD中含有横向滚动视图就删除，否则在控件联动隐藏时出现问题
     * @param td 可能含有横向滚动视图的TD
     */
    private void removeHorizontalScrollViewInTD(LPLayout td){
    	try{
       	 View view = ((ViewGroup) td.realView_).getChildAt(0);
    	 if(null != view && view instanceof HSView){
    		 HSView hs = (HSView)view;
    		 AbsoluteLayout absl = (AbsoluteLayout) (hs).getChildAt(0);
    		 if(null != absl && absl.getChildCount() > 0){
    			 int count = absl.getChildCount();
    			 Component[] comps = new Component[count];
    			 for(int i = 0 ;i < comps.length;i++){
    				 View v = absl.getChildAt(i);
    				 comps[i] = getComponent(v);
    				 absl.removeView(v);
    			 }
    			 hs.removeView(absl);
    			 ((MyLPLayout)td.realView_).removeView(hs);
    			 td.removeAllViews();
    			 for(int i = 0 ;i < comps.length;i++){
    				 ((MyLPLayout) td.realView_).addView(comps[i].realView_,comps[i].getLayoutParams());
    			 }
    			 comps = null;
    		 }
    	 }
    	}catch(Exception e){
    		Utils.printException(e);
    	}
    }
    
    /**
     * 插入横向滚动视图。
     * 
     * @param layout 需要插入横向滚动视图的组件。
     * @param contentWidth 内容的宽度。
     */
    private void insertHorizontalScrollViewInTD(LPLayout layout, int contentWidth){
    	// 初始化一个横向滚动视图。
		HSView hs = new HSView(layout.getContext());
		// 滚动视图的宽高就使用td的布局参数。
		hs.setLayoutParams(new LinearLayout.LayoutParams(layout.width_, layout.height_));
		// 获得需要在里面添加的内容。
		AbsoluteLayout content = new AbsoluteLayout(layout.getContext());
		content.setLayoutParams(new AbsoluteLayout.LayoutParams(
				contentWidth, layout.height_, 0, 0));
		// 将原有的内容加入横向滚动视图。
		for (int j = 0; j < layout.getCompChildCount(); j++) {
			Component child = layout.getCompChildAt(j);
			layout.removeView(child);
			content.addView(child.realView_, child.getLayoutParams());
			child.regHS(child, hs); // 给放入横向滚动视图中的控件登记hs。
		}
		hs.addView(content);
		// 清空原来的所有内容，包括已经添加的横向滚动视图。
		layout.removeAllViews();
		// 将横向滚动视图加入td。
		((MyLPLayout) layout.realView_).addView(hs);
    }
    
    /**
     * 插入纵向滚动视图。
     * 
     * @param layout 需要插入纵向滚动视图的组件。
     * @param contentWidth 内容的高度。
     */
    private void insertVerticalScrollViewOutTable(LPLayout layout, int contentHeight){
    	if(layout != null && layout.getParent() != null && layout.getParent() instanceof LPLayout
    			&& layout.height_ > 0){ // 表格的高度要有确定的值，否则不进行插入纵向滚动条的操作。
    		LPLayout parent = (LPLayout) layout.getParent(); // 表格的父视图。
    		int layoutIndex = parent.indexOfChild(layout.realView_); // 表格在父视图中的序号。
    		// 生成一个滚动视图。
            LPScrollView sv = new LPScrollView(layout.getContext());
            sv.setLayoutParams(new LinearLayout.LayoutParams(layout.width_, layout.height_));
            sv.isPartlyScroll_ = true; // 声明这个滚动视图仅仅是局部滚动。
            // 父控件中去掉表格。
            parent.removeView(layout);
            // 把表格加入滚动视图。
            LayoutParams lp = (LayoutParams) layout.getLayoutParams();
            lp.height = contentHeight;
            layout.setLayoutParams(lp);
            sv.addView(layout);
            // 表格的所有子元素都登记这个滚动视图，用来解决点击恢复tr颜色和其他关于焦点的问题。
            layout.regVS(layout, sv);
            // 把滚动视图放回原来表格的位置。
            parent.addView(sv, layoutIndex);
    	}
    }

    /**
     * 插入滚动视图。这个滚动视图的加入指的是整体页面而言的，比如在body或者llv上加入滚动视图。
     */
    private void insertScrollView() {
        if (getTag().equalsIgnoreCase("table") || getTag().equalsIgnoreCase("tr") || getTag().equalsIgnoreCase("td")
                || getTag().equalsIgnoreCase("th"))
            return;
        if (hasRolledView(realView_))
            return;
        ViewGroup vg = (ViewGroup) realView_.getParent();
        if (null != vg && (vg instanceof ScrollView))
            return;
//        Object o = null;
//        int size = Component.VWIDGETARRAY.size();
//        for (int i = 0; i < size; i++) {
//            o = Component.VWIDGETARRAY.get(i);
////            if (o instanceof LPAmap) {
////                return;// 如果添加了地图控件，那么不能插入scrollview，否则会导致地图的拖动出问题。
////            }
//        }
        if (getTag().equalsIgnoreCase("body")) {
            if (null == realView_)
                return;
            int childSize = getChildCount();
            Component child = null;
            int indexLLV = Integer.MIN_VALUE;

            for (int i = 0; i < childSize; i++) {
                child = getChildAt(i);
                // 取得llv框架在body框架的位置
                if (child.getTag().equals("llv")) {
                    indexLLV = i;
                    break;
                }
            }
            // 如果页面上有llv，并且llv的高度超过了他自身的标准高度，那么就插入一个滚动视图。
            // (&& child.getLayoutParams().height < child.hSelfMax_)
            if (indexLLV != Integer.MIN_VALUE ) {//默认添加ScrollView
            	// 生成一个滚动视图。
                LPScrollView sv = new LPScrollView(getContext());
                // 设置滚动距离上限。
                sv.setLimitY(child.hSelfMax_ - child.getLayoutParams().height);
                // 拿到llv控件。
                child = getChildAt(indexLLV);
                // 如果控件标记不为body，则对其限制大小，拿到llv布局参数。
                LayoutParams lp = (LayoutParams) child.getLayoutParams();
                // 滚动视图控件设置一下布局参数，参数就用llv的布局参数，
                sv.setLayoutParams(lp);
                // 去除llv。
                removeView(child);
                // 把llv加入滚动视图。
                sv.addView(child);
                sv.setTag("llvSV");
                // 把滚动视图放回原来llv的位置。
                addView(sv, indexLLV);
                Utils.sc_ = sv;
            } else {
                LPScrollView sv = new LPScrollView(getContext());
                sv.addView(this);
                sv.setTag("llvSV");
                ComponentCopy.COMPONENT = sv;
                ComponentCopy.COMPONENTPARTLY = sv;
                Utils.sc_ = sv;
            }
        } 
    }

    /**
     * 判断是否有滚动的View对象 由于两个滚动组件叠加会产生问题所以在此做判断如果有滚动组件如（WebView,MapView,GridView等）
     * 就不再插入ScrollView组件
     * 
     * @param view
     * @return
     */
    private boolean hasRolledView(View view) {
        boolean hasRolledView = false;
//        if (view instanceof WebView || view instanceof MapView) {
        if (view instanceof WebView) {
            return true;
        } else if (view instanceof ViewGroup) {
            ViewGroup vg = (ViewGroup) view;
            int count = vg.getChildCount();
            for (int i = 0; i < count; i++) {
                hasRolledView = hasRolledView(vg.getChildAt(i));
                if (hasRolledView)
                    return true;
            }
        }

        return hasRolledView;
    }

    int getPaddingBottom() {
        // TODO Auto-generated method stub
        if (null != realView_)
            return realView_.getPaddingBottom();
        return 0;
    }

    int getPaddingTop() {
        // TODO Auto-generated method stub
        if (null != realView_)
            return realView_.getPaddingTop();
        return 0;
    }

    /**
     * 设置管理器的最大高度
     * 
     * @param max
     */
    void setHMax(int max) {
        // TODO Auto-generated method stub
        hSelfMax_ = max;
    }

    /**
     * 将原有控件的位置、空行等属性赋给新控件
     * 
     * @param cOMPONENTPARTLY
     * @return
     */
    private LPLayout updateComponent(Component cOMPONENTPARTLY) {
        LPLayout lpl = (LPLayout) cOMPONENTPARTLY;
        lpl.ySelfTop_ = ySelfTop_;
        lpl.isAfterBr_ = isAfterBr_;
        LayoutParams lp = (LayoutParams) getLayoutParams();
        LayoutParams lpTemp = (LayoutParams) lpl.getLayoutParams();
        lpTemp.x = lp.x;
        lpTemp.y = lp.y;
        lpl.setLayoutParams(lpTemp);
        return lpl;
    }

    /**
     * 设置管理器的最大高度。
     * @param max
     */
    public void setWMax(int max) {
        // TODO Auto-generated method stub
        wSelfMax_ = max;
    }

    /**
     * 取得子元素对应的序号
     * 
     * @param realView
     * @return
     */
    public int indexOfChild(View realView) {
        // TODO Auto-generated method stub
        MyLPLayout temp = (MyLPLayout) realView_;
        return temp.indexOfChild(realView);
    }

    /**
     * 计算llv的直接子元素应该修正的top值�?
     * 
     * @return
     */
    public int getLLVTop() {
        // TODO Auto-generated method stub
        parent_ = (LPLayout) getParent();
        Component cfirst = parent_.getChildAt(0);
        String fixProperty = (String) cfirst.getStyleByName("position");
        if (null != fixProperty && fixProperty.equalsIgnoreCase("fixed")) {
            if (cfirst.height_ > 0)
                return cfirst.height_;
            else {
                return cfirst.hSelfMax_;
            }
        }
        return 0;
    }

    /**
     * 设置tr表格控件的分割线颜色，该分割线为上分割线
     * 
     * @param attrString
     */
    public void setSeparator() {
        if (null == getTag() || (null != getTag() && !getTag().equalsIgnoreCase("table")))
            return;
        String colorstr = (String) getPropertyByName("separator");
        if (null == colorstr || colorstr.equals(""))
            return;

        try {
            separatorColor_ = 0xFF000000;
            colorstr = Utils.getValidColorString(colorstr);
            separatorColor_ = Integer.parseInt(colorstr, 16);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            Utils.printException(e);
            // 分割线默认为黑色
            separatorColor_ = 0xFF000000;
        }
        separatorColor_ |= 0xFF000000;
    }
    
    /**
     * 设置table表格控件的纵向分割线颜色。
     * 
     * @param attrString
     */
    public void setVerticalSeparator() {
        if (null == getTag() || (null != getTag() && !getTag().equalsIgnoreCase("table")))
            return;
        String verticalColorstr = (String) getPropertyByName("verticalSeparator");
        if (null == verticalColorstr || verticalColorstr.equals(""))
            return;

        try {
            verticalSeparatorColor_ = 0xFF000000;
            verticalColorstr = Utils.getValidColorString(verticalColorstr);
            verticalSeparatorColor_ = Integer.parseInt(verticalColorstr, 16);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            Utils.printException(e);
            // 分割线默认为黑色
            verticalSeparatorColor_ = 0xFF000000;
        }
        verticalSeparatorColor_ |= 0xFF000000;
    }
    
    /**
     * 获取框架纵向边距
     * 
     * @return
     */
    public int getVM() {
        String tag = getTag();
        if (null != tag && !tag.equals("")) {
            if (tag.equalsIgnoreCase("body") || tag.equalsIgnoreCase("llv"))
                return VMB;
            else if (tag.equalsIgnoreCase("form"))
                return VMF;
            else if (tag.equalsIgnoreCase("div"))
                return VMD;
            else if (tag.equalsIgnoreCase("td") || tag.equalsIgnoreCase("th"))
                return VMT;
        }
        return 0;
    }

    /**
     * 获取框架横向边距
     * 
     * @return
     */
    public int getHM() {
        String tag = getTag();
        if (null != tag && !tag.equals("")) {
            if (tag.equalsIgnoreCase("body") || tag.equalsIgnoreCase("llv"))
                return HMB;
            else if (tag.equalsIgnoreCase("form"))
                return HMF;
            else if (tag.equalsIgnoreCase("div"))
                return HMD;
            else if (tag.equalsIgnoreCase("td") || tag.equalsIgnoreCase("th"))
                return HMT;
        }
        return 0;
    }

    /**
     * 获取框架子元素纵向间距
     * 
     * @return
     */
    public int getVG() {
        String tag = getTag();
        if (null != tag && !tag.equals("")) {
            if (tag.equalsIgnoreCase("body") || tag.equalsIgnoreCase("llv"))
                return VGB;
            else if (tag.equalsIgnoreCase("form"))
                return VGF;
            else if (tag.equalsIgnoreCase("div"))
                return VGD;
            else if (tag.equalsIgnoreCase("td") || tag.equalsIgnoreCase("th"))
                return VGT;
        }
        return 0;
    }

    /**
     * 获取框架子元素横向间距
     * 
     * @return
     */
    public int getHG() {
        String tag = getTag();
        if (null != tag && !tag.equals("")) {
            if (tag.equalsIgnoreCase("body") || tag.equalsIgnoreCase("llv"))
                return HGB;
            else if (tag.equalsIgnoreCase("form"))
                return HGF;
            else if (tag.equalsIgnoreCase("div"))
                return HGD;
            else if (tag.equalsIgnoreCase("td") || tag.equalsIgnoreCase("th"))
                return HGT;
        }
        return 0;
    }

    public void setPadding(int left, int top, int right, int bottom) {
        // TODO Auto-generated method stub
        if (null != realView_)
            realView_.setPadding(left, top, right, bottom);
    }
}
